package lexer

// TokenType 表示词法单元的类型
type TokenType int

// 定义SQL中所有可能的Token类型
const (
	// 特殊Token
	ILLEGAL    TokenType = iota // 非法字符
	EOF                         // 文件结束标记
	WHITESPACE                  // 空白字符

	// 标识符和字面量
	IDENTIFIER // 标识符，如表名、列名等
	STRING     // 字符串字面量，如 'abc'
	NUMBER     // 数字字面量，如 123, 45.67

	// 运算符
	EQUAL         // 等于: =
	NOT_EQUAL     // 不等于: != 或 <>
	LESS          // 小于: <
	LESS_EQUAL    // 小于等于: <=
	GREATER       // 大于: >
	GREATER_EQUAL // 大于等于: >=
	PLUS          // 加号: +
	MINUS         // 减号: -
	ASTERISK      // 星号/乘号: *
	SLASH         // 斜杠/除号: /

	// 分隔符
	COMMA     // 逗号: ,
	SEMICOLON // 分号: ;
	DOT       // 点号: .
	LPAREN    // 左括号: (
	RPAREN    // 右括号: )

	// SQL关键字
	SELECT     // SELECT关键字
	INSERT     // INSERT关键字
	UPDATE     // UPDATE关键字
	DELETE     // DELETE关键字
	FROM       // FROM关键字
	WHERE      // WHERE关键字
	CREATE     // CREATE关键字
	DROP       // DROP关键字
	TABLE      // TABLE关键字
	INTO       // INTO关键字
	VALUES     // VALUES关键字
	SET        // SET关键字
	AND        // AND关键字
	OR         // OR关键字
	NOT        // NOT关键字
	NULL       // NULL关键字
	INT        // INT数据类型
	VARCHAR    // VARCHAR数据类型
	PRIMARY    // PRIMARY关键字
	KEY        // KEY关键字
	FOREIGN    // FOREIGN关键字
	REFERENCES // REFERENCES关键字

	// ALTER TABLE相关关键字
	ALTER      // ALTER关键字
	ADD        // ADD关键字
	COLUMN     // COLUMN关键字
	MODIFY     // MODIFY关键字
	CHANGE     // CHANGE关键字
	CONSTRAINT // CONSTRAINT关键字
	UNIQUE     // UNIQUE关键字
	DEFAULT    // DEFAULT关键字
	COMMENT    // COMMENT关键字

	// ORDER BY相关关键字
	ORDER // ORDER关键字
	BY    // BY关键字
	ASC   // ASC关键字(升序)
	DESC  // DESC关键字(降序)

	// LIMIT相关关键字
	LIMIT // LIMIT关键字

	// JOIN相关关键字
	INNER TokenType = iota + 100 // 从100开始，避免与现有类型冲突
	LEFT
	RIGHT
	FULL
	JOIN
	ON
	AS
)

// String 返回TokenType的字符串表示
// 实现fmt.Stringer接口，使TokenType可以用%s格式化
func (tt TokenType) String() string {
	switch tt {
	case ILLEGAL:
		return "ILLEGAL"
	case EOF:
		return "EOF"
	case WHITESPACE:
		return "WHITESPACE"
	case IDENTIFIER:
		return "IDENTIFIER"
	case STRING:
		return "STRING"
	case NUMBER:
		return "NUMBER"
	case EQUAL:
		return "="
	case NOT_EQUAL:
		return "!="
	case LESS:
		return "<"
	case LESS_EQUAL:
		return "<="
	case GREATER:
		return ">"
	case GREATER_EQUAL:
		return ">="
	case PLUS:
		return "+"
	case MINUS:
		return "-"
	case ASTERISK:
		return "*"
	case SLASH:
		return "/"
	case COMMA:
		return ","
	case SEMICOLON:
		return ";"
	case DOT:
		return "."
	case LPAREN:
		return "("
	case RPAREN:
		return ")"
	case SELECT:
		return "SELECT"
	case INSERT:
		return "INSERT"
	case UPDATE:
		return "UPDATE"
	case DELETE:
		return "DELETE"
	case FROM:
		return "FROM"
	case WHERE:
		return "WHERE"
	case CREATE:
		return "CREATE"
	case DROP:
		return "DROP"
	case TABLE:
		return "TABLE"
	case INTO:
		return "INTO"
	case VALUES:
		return "VALUES"
	case SET:
		return "SET"
	case AND:
		return "AND"
	case OR:
		return "OR"
	case NOT:
		return "NOT"
	case NULL:
		return "NULL"
	case INT:
		return "INT"
	case VARCHAR:
		return "VARCHAR"
	case PRIMARY:
		return "PRIMARY"
	case KEY:
		return "KEY"
	case FOREIGN:
		return "FOREIGN"
	case REFERENCES:
		return "REFERENCES"
	case ALTER:
		return "ALTER"
	case ADD:
		return "ADD"
	case COLUMN:
		return "COLUMN"
	case MODIFY:
		return "MODIFY"
	case CHANGE:
		return "CHANGE"
	case CONSTRAINT:
		return "CONSTRAINT"
	case UNIQUE:
		return "UNIQUE"
	case DEFAULT:
		return "DEFAULT"
	case COMMENT:
		return "COMMENT"
	case ORDER:
		return "ORDER"
	case BY:
		return "BY"
	case ASC:
		return "ASC"
	case DESC:
		return "DESC"
	case LIMIT:
		return "LIMIT"
	case INNER:
		return "INNER"
	case LEFT:
		return "LEFT"
	case RIGHT:
		return "RIGHT"
	case FULL:
		return "FULL"
	case JOIN:
		return "JOIN"
	case ON:
		return "ON"
	case AS:
		return "AS"
	default:
		return "未知Token类型"
	}
}

// keywords 将关键字字符串映射到对应的TokenType
var keywords = map[string]TokenType{
	"select":     SELECT,
	"insert":     INSERT,
	"update":     UPDATE,
	"delete":     DELETE,
	"from":       FROM,
	"where":      WHERE,
	"create":     CREATE,
	"drop":       DROP,
	"table":      TABLE,
	"into":       INTO,
	"values":     VALUES,
	"set":        SET,
	"and":        AND,
	"or":         OR,
	"not":        NOT,
	"null":       NULL,
	"int":        INT,
	"varchar":    VARCHAR,
	"primary":    PRIMARY,
	"key":        KEY,
	"foreign":    FOREIGN,
	"references": REFERENCES,
	"alter":      ALTER,
	"add":        ADD,
	"column":     COLUMN,
	"modify":     MODIFY,
	"change":     CHANGE,
	"constraint": CONSTRAINT,
	"unique":     UNIQUE,
	"default":    DEFAULT,
	"comment":    COMMENT,
	"order":      ORDER,
	"by":         BY,
	"asc":        ASC,
	"desc":       DESC,
	"limit":      LIMIT,
	"inner":      INNER,
	"left":       LEFT,
	"right":      RIGHT,
	"full":       FULL,
	"join":       JOIN,
	"on":         ON,
	"as":         AS,
}

// LookupIdent 检查给定标识符是否为SQL关键字
func LookupIdent(ident string) TokenType {
	if tok, ok := keywords[ident]; ok {
		return tok
	}
	return IDENTIFIER
}

// Token 表示SQL文本中的一个词法单元
type Token struct {
	Type    TokenType // token类型
	Literal string    // token的字面值
	Line    int       // token在源码中的行号
	Column  int       // token在源码中的列号
}

// String 返回Token的字符串表示
func (t Token) String() string {
	return t.Literal
}
